if(window) {
if(window.VectorB) {
    throw new Error('VecotrB被占用');
} else {

/**
 * 之前的Vector类，都重在修改原始属性值，意在对图像对象产生影响。
 * VectorB类，则更侧重向量的计算和构造，不修改原始值，而是返回一个全新向量对象
 */
window.VectorB = (function () {

    /**
     * 向量构造类的构造函数
     * @param {Number} x 向量点x坐标
     * @param {Number} y 向量点y坐标
     */
    function VectorB(x, y) {
        if(typeof x === 'object') {
            y = x.y;
            x = x.x;
        }
        this.x = x || 0;
        this.y = y || 0;
    }

    VectorB.prototype = {

        /**
         * 计算向量的 “模”
         */
        getMagnitude: function () {
            return Math.sqrt( Math.pow(this.x, 2) + Math.pow(this.y, 2) );
        },

        /**
         * 计算和向量
         */
        add: function (vector) {
            var v = new VectorB();
            v.x = this.x + vector.x;
            v.y = this.y + vector.y;
            return v;
        },

        /**
         * 计算差向量
         */
        sub: function (vector) {
            var v = new VectorB();
            v.x = this.x - vector.x;
            v.y = this.y - vector.y;
            return v;
        },

        /**
         * 计算点积（标量）
         */
        dotProduct: function (vector) {
            return this.x * vector.x + this.y * vector.y;
        },

        /**
         * 边向量
         * 往往是两个同源向量的差向量
         */
        edge: function (vector) {
            return this.sub(vector);
        },

        /**
         * 法向量
         */
        perpendicular: function () {
            var v = new VectorB();
            v.x = this.y;
            v.y = 0 - this.x;
            return v;
        },

        /**
         * 规则化（模置1）
         * 计算单位向量
         */
        normalize: function () {
            var v = new VectorB(),
                m = this.getMagnitude();
            if(m !== 0) {
                v.x = this.x / m;
                v.y = this.y / m;
            }
            return v;
        },

        /**
         * 单位法向量
         */
        normal: function () {
            var p = this.perpendicular();
            return p.normalize();
        }
    }

    return VectorB;

}());

}
} else {
    throw new Error('环境错误');
}